/**
 * 图书状态管理
 * 使用Pinia管理图书数据和推荐信息
 */
import { defineStore } from 'pinia';
import api from '@/api/index.js';

// 定义图书状态store
export const useBookStore = defineStore('book', {
  // 状态数据
  state: () => ({
    // 热门图书列表
    hotBooks: [],
    // 新上架图书列表
    newBooks: [],
    // 推荐图书列表
    recommendBooks: [],
    // 个性化推荐图书列表
    personalRecommendations: [],
    // 分类列表
    categories: [],
    // 当前图书详情
    currentBook: null,
    // 相似图书列表
    similarBooks: [],
    // 加载状态
    loading: {
      hot: false,
      new: false,
      recommend: false,
      personal: false,
      category: false,
      detail: false,
      similar: false
    },
    // 错误信息
    error: null
  }),
  
  // 计算属性
  getters: {
    // 获取分类名称列表
    categoryNames: (state) => state.categories.map(item => item.name)
  },
  
  // 操作方法
  actions: {
    /**
     * 获取热门图书
     * @param {Object} params 查询参数 {page, size}
     * @returns {Promise<Array>} 热门图书列表
     */
    async fetchHotBooks(params = { page: 1, size: 10 }) {
      try {
        this.loading.hot = true;
        
        const res = await api.recommendation.getHotBooks(params);
        
        if (res && res.data) {
          this.hotBooks = res.data.list || [];
          return res.data.list || [];
        } else {
          throw new Error('获取热门图书失败');
        }
      } catch (error) {
        this.error = error.message || '获取热门图书失败';
        console.error('获取热门图书失败:', error);
        // 返回空数组避免前端报错
        return [];
      } finally {
        this.loading.hot = false;
      }
    },
    
    /**
     * 获取分类下的热门图书
     * @param {String|Number} categoryId 分类ID
     * @param {Object} params 查询参数 {page, size}
     * @returns {Promise<Array>} 热门图书列表
     */
    async fetchHotBooksByCategory(categoryId, params = { page: 1, size: 10 }) {
      try {
        this.loading.hot = true;
        
        const res = await api.recommendation.getHotBooksByCategory(categoryId, params);
        
        if (res && res.data) {
          return res.data.list || [];
        } else {
          throw new Error('获取分类热门图书失败');
        }
      } catch (error) {
        this.error = error.message || '获取分类热门图书失败';
        console.error('获取分类热门图书失败:', error);
        // 返回空数组避免前端报错
        return [];
      } finally {
        this.loading.hot = false;
      }
    },
    
    /**
     * 获取新上架图书
     * @param {Object} params 查询参数 {page, size}
     * @returns {Promise<Array>} 新上架图书列表
     */
    async fetchNewBooks(params = { page: 1, size: 10 }) {
      try {
        this.loading.new = true;
        
        const res = await api.recommendation.getNewBooks(params);
        
        if (res && res.data) {
          this.newBooks = res.data.list || [];
          return res.data.list || [];
        } else {
          throw new Error('获取新上架图书失败');
        }
      } catch (error) {
        this.error = error.message || '获取新上架图书失败';
        console.error('获取新上架图书失败:', error);
        // 返回空数组避免前端报错
        return [];
      } finally {
        this.loading.new = false;
      }
    },
    
    /**
     * 获取分类下的新上架图书
     * @param {String|Number} categoryId 分类ID
     * @param {Object} params 查询参数 {page, size}
     * @returns {Promise<Array>} 新上架图书列表
     */
    async fetchNewBooksByCategory(categoryId, params = { page: 1, size: 10 }) {
      try {
        this.loading.new = true;
        
        const res = await api.recommendation.getNewBooksByCategory(categoryId, params);
        
        if (res && res.data) {
          return res.data.list || [];
        } else {
          throw new Error('获取分类新上架图书失败');
        }
      } catch (error) {
        this.error = error.message || '获取分类新上架图书失败';
        console.error('获取分类新上架图书失败:', error);
        // 返回空数组避免前端报错
        return [];
      } finally {
        this.loading.new = false;
      }
    },
    
    /**
     * 获取个性化推荐
     * @param {Number} userId 用户ID
     * @param {Object} params 查询参数 {page, size}
     * @returns {Promise<Array>} 推荐图书列表
     */
    async fetchPersonalRecommendations(userId, params = { page: 1, size: 10 }) {
      try {
        this.loading.personal = true;
        
        const res = await api.recommendation.getPersonalRecommendations(userId, params);
        
        if (res && res.data) {
          this.personalRecommendations = res.data.list || [];
          return res.data.list || [];
        } else {
          throw new Error('获取个性化推荐失败');
        }
      } catch (error) {
        this.error = error.message || '获取个性化推荐失败';
        console.error('获取个性化推荐失败:', error);
        // 如果获取个性化推荐失败，则返回热门图书
        return await this.fetchHotBooks(params);
      } finally {
        this.loading.personal = false;
      }
    },
    
    /**
     * 获取相似图书
     * @param {Number} bookId 图书ID
     * @param {Object} params 查询参数 {page, size}
     * @returns {Promise<Array>} 相似图书列表
     */
    async fetchSimilarBooks(bookId, params = { page: 1, size: 10 }) {
      try {
        this.loading.similar = true;
        
        const res = await api.recommendation.getSimilarBooks(bookId, params);
        
        if (res && res.data) {
          this.similarBooks = res.data.list || [];
          return res.data.list || [];
        } else {
          throw new Error('获取相似图书失败');
        }
      } catch (error) {
        this.error = error.message || '获取相似图书失败';
        console.error('获取相似图书失败:', error);
        // 返回空数组避免前端报错
        return [];
      } finally {
        this.loading.similar = false;
      }
    },
    
    /**
     * 获取作者其他作品
     * @param {Number} authorId 作者ID
     * @param {Object} params 查询参数 {page, size}
     * @returns {Promise<Array>} 作者其他作品列表
     */
    async fetchAuthorOtherBooks(authorId, params = { page: 1, size: 10 }) {
      try {
        const res = await api.recommendation.getAuthorOtherBooks(authorId, params);
        
        if (res && res.data) {
          return res.data.list || [];
        } else {
          throw new Error('获取作者其他作品失败');
        }
      } catch (error) {
        console.error('获取作者其他作品失败:', error);
        // 返回空数组避免前端报错
        return [];
      }
    },
    
    /**
     * 获取图书详情
     * @param {Number} bookId 图书ID
     * @returns {Promise<Object>} 图书详情
     */
    async fetchBookDetail(bookId) {
      try {
        this.loading.detail = true;
        
        const res = await api.book.getBookDetail(bookId);
        
        if (res && res.data) {
          this.currentBook = res.data;
          return res.data;
        } else {
          throw new Error('获取图书详情失败');
        }
      } catch (error) {
        this.error = error.message || '获取图书详情失败';
        console.error('获取图书详情失败:', error);
        return null;
      } finally {
        this.loading.detail = false;
      }
    },
    
    /**
     * 获取所有分类
     * @returns {Promise<Array>} 分类列表
     */
    async fetchCategories() {
      try {
        this.loading.category = true;
        
        const res = await api.category.getAllCategories();
        
        if (res && res.data) {
          // 确保返回的实际是数组
          const categoriesList = res.data.list || [];
          
          // 更新到商店中
          this.categories = categoriesList;
          return categoriesList;
        } else {
          throw new Error('获取分类列表失败');
        }
      } catch (error) {
        this.error = error.message || '获取分类列表失败';
        console.error('获取分类列表失败:', error);
        
        // 返回空数组避免前端报错
        this.categories = [];
        return [];
      } finally {
        this.loading.category = false;
      }
    },
    
    /**
     * 获取分类详情
     * @param {Number} categoryId 分类ID
     * @returns {Promise<Object>} 分类详情
     */
    async fetchCategoryDetail(categoryId) {
      try {
        const res = await api.category.getCategoryDetail(categoryId);
        
        if (res && res.data) {
          return res.data;
        } else {
          throw new Error('获取分类详情失败');
        }
      } catch (error) {
        this.error = error.message || '获取分类详情失败';
        console.error('获取分类详情失败:', error);
        return null;
      }
    },
    
    /**
     * 获取分类下的图书
     * @param {Number} categoryId 分类ID
     * @param {Object} params 查询参数 {page, size, sort, order}
     * @returns {Promise<Array>} 图书列表
     */
    async fetchCategoryBooks(categoryId, params = { page: 1, size: 10 }) {
      try {
        const res = await api.category.getCategoryBooks(categoryId, params);
        
        if (res && res.data) {
          return res.data.list || [];
        } else {
          throw new Error('获取分类图书失败');
        }
      } catch (error) {
        this.error = error.message || '获取分类图书失败';
        console.error('获取分类图书失败:', error);
        // 返回空数组避免前端报错
        return [];
      }
    },
    
    /**
     * 搜索图书
     * @param {Object} params 搜索参数 {keyword, page, size, sort, order, categoryId}
     * @returns {Promise<Array>} 搜索结果
     */
    async searchBooks(params = { keyword: '', page: 1, size: 10 }) {
      try {
        const res = await api.book.searchBooks(params);
        
        if (res && res.data) {
          return res.data;
        } else {
          throw new Error('搜索图书失败');
        }
      } catch (error) {
        console.error('搜索图书失败:', error);
        // 返回空结果对象避免前端报错
        return { list: [], total: 0 };
      }
    }
  }
});
